#pragma once
#include "dictionary.h"
#include <map>
#include <utility>

//���������� ����������� ����� ����������, ����������� ���������
// dictionary � ��������� ��������� ����������, ����������� ��������� not_found_exception.
//��� ���������� ����������� ������������ STL.����� �����, ���������� ���������� ����� �� ����������.

template<class Key, class Value>
class inheritor: public dictionary<Key, Value>
{
    std::map<Key, Value> m_map{};
public:
    inheritor() = default;
    inheritor(std::initializer_list <std::pair<Key, Value>> list);
    virtual ~inheritor() = default;

    virtual const Value& get(const Key& key) const;
    virtual void set(const Key& key, const Value& value);
    virtual bool is_set(const Key& key) const;
};

template<class Key>
class inheritor_not_found_exception: public not_found_exception<Key>
{
    Key m_key;
public:
    inheritor_not_found_exception(const Key& key) :m_key(key) {};
    virtual const Key& get_key() const noexcept { return m_key;};
};


template<class Key, class Value>
inline inheritor<Key, Value>::inheritor(std::initializer_list <std::pair<Key, Value>> list)
{
    for (const auto& x : list)
    {
        m_map.insert(x);
    }
}


template<class Key, class Value>
inline const Value& inheritor<Key, Value>::get(const Key& key) const
{
    if (m_map.empty() || !m_map.count(key)) {throw inheritor_not_found_exception<Key>(key); }
    else return m_map.find(key)->second;
}

template<class Key, class Value>
inline void inheritor<Key, Value>::set(const Key& key, const Value& value)
{   
    bool fl = m_map.insert(std::pair<Key, Value>(key, value)).second;
}

template<class Key, class Value>
inline bool inheritor<Key, Value>::is_set(const Key& key) const
{
    if (m_map.empty() || !m_map.count(key)) { return false; }
    else return true;
}


